Special Closures in R#

introduction: closure expression

A closure expression is a kind of expression group that could produce values, here is a closure expression example:

{
    function1();
    function2();
    function3();
}

As the result value of the closure expression is the value of the last expression, so you can assign the closure its expression value to a R# symbol like:

# you can apply the closure expression syntax for divide your code 
# into different code block in a more logical way. 
let symbol as string = {
    function1();
    function2();

    # the result value of the function3 invocation will be 
    # assigned to the target symbol.
    function3();
}

NOTE: please note that, the closure is an expression, even if the closure body it contains multiple expressions.

There are sevral special closure types in R# language

using closure

The using closure can apply for the automatically operation like write file, send data automatically when finish the operations, example as:

using file as data.frame() :> auto(table -> table :> write.csv(file = "...")) {
    # codes for modify the file data frame object
    # ...
}

if we restore the the using closure code as the original R code, then you can found out the secret of how we implements the using closure:

let file = data.frame();

# codes for modify the file data frame object
# ...

write.csv(file, file = "...")

acceptor closure

The acceptor closure is a kind of extension function syntax. By using the acceptor closure syntax that we can divide the code into different code block in a more logical way. For example, draw bitmap in the original R language syntax could be:

# code for charting...
plot(...)
# more charting code 
# ...
:> bitmap(...);

But with the new acceptor closure syntax, that you can divide your code into blocks by different logical function implementation, example like:

bitmap(...) {
    # code for charting...
    # ...
    plot(...);
}

the acceptor closure syntax is a kind of syntax variation of extension function, example like the extension function:

# the pipeline code produce the input table value for write.csv function
get_source
:> func1()
:> func2()
:> func3()
:> func4()
:> write.csv(file = "...");

the extension function syntax code that show above is equivalent to the acceptor syntax, example like:

write.csv(file = "...") {
    # the pipeline code produce the input table value for write.csv function
    get_source
    :> func1()
    :> func2()
    :> func3()
    :> func4();
}

if we rewrite the above code into the original R syntax, then you will find the secret of how to implements such so called acceptor syntax:

write.csv({
    # the pipeline code produce the input table value for write.csv function
    get_source
    :> func1()
    :> func2()
    :> func3()
    :> func4();
}, file = "...");